#include <iostream>
#include "Classe_point.h"
#include <vector>

using namespace std;

int main(void) {
  /*
   * On constate que le nombre d'appel au constructeur est le meme que le nombre
   * d'appel au destructeur. Cependant les 3 derniers appels au destructeur se 
   * font de maniere automatique alors que le premier est cause par le delete
   */


  Point A; // premier appel de base
  Point B(1.1,2.1); // deuxieme appel avec le constructeur de surcharge
  Point C(B); // troisieme appel avec le constructeur de copie
  Point& D = A; // pas d'appel car on ne fait au'une reference sur un objet
  Point* E = new Point(5.0,5.0); // quatrieme appel ou on utilise le constructeur de surcharge
  //Point* I = &A;

  Point* F = new Point[3]();

  //I->setX(11.0); // maintenant A = (11.0,0);

  cout << "coord B (" << B.getX() << ", " << B.getY() << ")"<< endl;
  cout << "coord D (" << D.getX() << ", " << D.getY() << ")"<< endl;
  cout << "coord E (" << E->getX() << ", " << E->getY() << ")"<< endl << endl;

  cout << "distance A et B = " << A.distance(B) << endl;
  cout << "distance C et D = " << C.distance(D) << endl;
  cout << "distance A et E = " << A.distance(*E) << endl;
  cout << "distance A et E = " << E->distance(A) << endl;
  cout << "distance A et E = " << E->distance(D) << endl << endl; // même chose puisque D est une référence sur A

  cout << "norme de A = " << B.getNorme() << endl;
  cout << "norme de D = " << D.getNorme() << endl << endl;
  
  delete E; // Appel du destructeur via le delete, ne se fait pas automatiquement comme les autres.
  //I = NULL;
  
  delete[] F;
  
  Point* G = new Point[3]();
  
  cout << "addr F = 0x" << hex << F << dec << endl;
  cout << "addr F[0] = 0x" << hex << &F[0] << dec << endl;
  cout << "addr F[1] = 0x" << hex << &F[1] << dec << endl;
  cout << "addr F[2] = 0x" << hex << &F[2] << dec << endl << endl;

  /*
   * Il s'agit des memes adresses car vu qu'on a desalloue la memoire 
   * precedemment du tableau F, on va pouvoir la reutiliser pour d'autres
   * allocations dynamiques. C'est exactement ce qu'il se passe dans notre cas.
   * La memoire desallouee precedemment est reutilisee lors de la declaration
   * du nouveau tableau G.
   * Si on avait pas la ligne Point* G = new Point[3](); avant mais à la fin, on
   * aurait des addresses différentes.
   */

  cout << "addr G = 0x" << hex << G << dec << endl;
  cout << "addr G[0] = 0x" << hex << &G[0] << dec << endl;
  cout << "addr G[1] = 0x" << hex << &G[1] << dec << endl;
  cout << "addr G[2] = 0x" << hex << &G[2] << dec << endl << endl;
  
  delete[] G;

  Point V;
  std::vector<Point> tabPoint(3,V);

  return 0;
}

